﻿using Library.AppWeb;
using MPR.Poker.Model.SYS;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MPR.Poker.DALEntity.SYS
{
    public class DAL_MemberType
    {
        public DAL_MemberType()
        {
        }

        #region Insert/Update/Delete

        /// <summary>
        /// Thêm mới loại thành viên tổng hợp
        /// </summary>
        /// <param name="objMemberType"></param>
        /// <returns></returns>
        public ResultMessage Insert(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                objResultMessage = CheckExist(objMemberType);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = InsertNoCheck(objMemberType);
                if (objResultMessage.IsError) return objResultMessage;
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi thêm loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> Insert");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Thêm loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Cập nhật loại thành viên tổng hợp
        /// </summary>
        /// <param name="objMemberType"></param>
        /// <returns></returns>
        public ResultMessage Update(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                objResultMessage = CheckExist(objMemberType);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = UpdateNoCheck( objMemberType);
                if (objResultMessage.IsError) return objResultMessage;
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi cập nhật loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> Update");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Cập nhật loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Xóa loại thành viên
        /// </summary>
        /// <param name="strMemberTypeID"></param>
        /// <returns></returns>
        public ResultMessage Delete(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            objResultMessage = CheckRelationship(objMemberType);
            if (objResultMessage.IsError) return objResultMessage;

            objResultMessage = DeleteNoCheck(objMemberType);

            return objResultMessage;
        }

        /// <summary>
        /// Xóa loại thành viên
        /// </summary>
        /// <param name="intMemberTypeIDSys">Mã loại thành viên</param>
        /// <param name="intDeletedMemberType">Mã loại thành viên</param>
        /// <returns></returns>
        public ResultMessage Delete(int intMemberTypeIDSys, int intDeletedMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_MemberType objMemberType = new SYS_MemberType();
            objMemberType.IDSys = intMemberTypeIDSys;

            objResultMessage = CheckRelationship(objMemberType);
            if (objResultMessage.IsError) return objResultMessage;

            objResultMessage = DeleteNoCheck(objMemberType);

            return objResultMessage;
        }

        /// <summary>
        /// Xóa loại thành viên
        /// </summary>
        /// <param name="lstMemberTypeIDSys">List đối tượng loại thành viên</param>
        /// <param name="intDeletedMemberType">Mã loại thành viên</param>
        /// <returns></returns>
        public ResultMessage Delete(List<int> lstMemberTypeIDSys, int intDeletedMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();

            foreach (int IDSys in lstMemberTypeIDSys)
            {
                SYS_MemberType objMemberType = new SYS_MemberType();
                objMemberType.IDSys = IDSys;

                objResultMessage = CheckRelationship(objMemberType);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = DeleteNoCheck(objMemberType);
                if (objResultMessage.IsError) return objResultMessage;
            }

            return objResultMessage;
        }

        /// <summary>
        /// Kiềm tra tồn tại loại thành viên
        /// </summary>
        /// <param name="strID"></param>
        /// <param name="strMemberTypeID"></param>
        /// <returns></returns>
        public ResultMessage CheckExist(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_MemberType MemberType = new SYS_MemberType();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    MemberType = db.SYS_MemberTypes.FirstOrDefault(i => i.IsDeleted == false & i.MemberTypeName == objMemberType.MemberTypeName & i.IDSys != objMemberType.IDSys);

                    if (MemberType != null && MemberType.MemberTypeName.Trim().Length > 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "loại thành viên đã tồn tại", string.Empty);
                    }
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Lỗi kiểm tra tồn tại loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> CheckExist");
                return objResultMessage;
            }
            return objResultMessage;
        }

        /// <summary>
        /// Kiểm tra dữ liệu liên quan
        /// </summary>
        /// <param name="strMemberTypeID"></param>
        /// <returns></returns>
        public ResultMessage CheckRelationship(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                //using (PokerLife db = new PokerLife())
                //{
                //    SYS_MemberType user = db.SYS_MemberTypes.FirstOrDefault(i => i.MemberTypeGroupIDSys == objMemberTypeGroup.IDSys);

                //    if (user != null && user.UID.Trim().Length > 0)
                //    {
                //        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.No_Error, "Có dữ liệu liên quan đến nhóm loại thành viên", string.Empty);
                //    }
                //}
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Lỗi kiểm tra dữ liệu liên quan loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> CheckRelationship");
                return objResultMessage;
            }
            return objResultMessage;
        }

        /// <summary>
        /// Thêm mới loại thành viên không cần kiểm tra
        /// </summary>
        /// <param name="objMemberType"></param>
        /// <returns></returns>
        public ResultMessage InsertNoCheck(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_MemberType MemberType = new SYS_MemberType();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    MemberType.MemberTypeName = objMemberType.MemberTypeName;                    
                    MemberType.Note = objMemberType.Note;                    
                    MemberType.OrderIndex = db.SYS_MemberTypes.Count() + 1;

                    db.SYS_MemberTypes.Add(MemberType);
                    db.SaveChanges();
                }
                objMemberType.IDSys = MemberType.IDSys;
                objMemberType.MemberTypeName = MemberType.MemberTypeName;
                DAL_Event.Insert("Thêm mới loại thành viên - " + MemberType.MemberTypeName.ToString(), 0, ResultMessage.ErrorTypes.Insert.ToString());
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi thêm loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> Insert");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Thêm loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Cập nhật loại thành viên không cần kiểm tra
        /// </summary>
        /// <param name="objMemberType"></param>
        /// <returns></returns>
        public ResultMessage UpdateNoCheck(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    SYS_MemberType MemberType = db.SYS_MemberTypes.FirstOrDefault(i => i.IDSys == objMemberType.IDSys);
                    MemberType.MemberTypeName = objMemberType.MemberTypeName;                   
                    MemberType.Note = objMemberType.Note;                    

                    db.SaveChanges();
                }

                DAL_Event.Insert("Cập nhật loại thành viên - " + objMemberType.MemberTypeName.ToString(), 0, ResultMessage.ErrorTypes.Update.ToString());
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Update, "Lỗi cập nhật loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> Update");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Cập nhật loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Xóa loại thành viên không cần kiểm tra
        /// </summary>
        /// <param name="objMemberType"></param>
        /// <returns></returns>
        public ResultMessage DeleteNoCheck(SYS_MemberType objMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    SYS_MemberType MemberType = db.SYS_MemberTypes.FirstOrDefault(i => i.IDSys == objMemberType.IDSys);
                    if (MemberType == null || MemberType.IDSys == 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "loại thành viên không tồn tại", string.Empty);
                        return objResultMessage;
                    }

                    MemberType.IsDeleted = true;
                    MemberType.DeletedDate = DateTime.Now;

                    db.SaveChanges();
                }

                DAL_Event.Insert("Xóa loại thành viên - " + objMemberType.MemberTypeName.ToString(), 0, ResultMessage.ErrorTypes.Delete.ToString());

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Delete, "Lỗi xóa loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> DeleteNoCheck");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Xóa loại thành viên thành công", string.Empty);
        }               

        #endregion

        #region Load/Search/Select

        /// <summary>
        /// Lấy thông tin loại thành viên
        /// </summary>
        /// <param name="objMemberType"></param>
        /// <param name="strID"></param>
        /// <returns></returns>
        public ResultMessage LoadInfo(ref SYS_MemberType objMemberType, int intMemberTypeIDSys)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var MemberType = from gu in db.SYS_MemberTypes
                               where gu.IDSys == intMemberTypeIDSys
                               select gu;
                    objMemberType = new SYS_MemberType();
                    foreach (var obj in MemberType)
                    {
                        if (!Convert.IsDBNull(obj.IDSys)) objMemberType.IDSys = obj.IDSys;
                        if (!string.IsNullOrEmpty(obj.MemberTypeName)) objMemberType.MemberTypeName = obj.MemberTypeName;                        
                        if (!string.IsNullOrEmpty(obj.Note)) objMemberType.Note = obj.Note;                        
                        if (!Convert.IsDBNull(obj.OrderIndex)) objMemberType.OrderIndex = obj.OrderIndex;
                        if (!Convert.IsDBNull(obj.IsDeleted)) objMemberType.IsDeleted = obj.IsDeleted;
                        if (!Convert.IsDBNull(obj.DeletedDate)) objMemberType.DeletedDate = obj.DeletedDate;
                    }
                }

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.LoadInfo, "Lấy thông tin loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> LoadInfo");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy thông tin loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách loại thành viên
        /// </summary>
        /// <param name="dtMemberType"></param>
        /// <returns></returns>
        public ResultMessage SearchData(ref DataTable dtMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            dtMemberType = new DataTable();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    dtMemberType = ConvertData.ConvertToDataTable<SYS_MemberType>(db.SYS_MemberTypes.Where(i => i.IsDeleted == false).ToList());
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SearchData, "Lấy thông tin loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> LoadInfo");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách loại thành viên dạng List
        /// </summary>
        /// <param name="lstMemberType"></param>
        /// <returns></returns>
        public ResultMessage SelectToList(ref List<SYS_MemberType> lstMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var MemberType = from gu in db.SYS_MemberTypes
                               where gu.IsDeleted == false
                               orderby gu.OrderIndex
                               select gu;
                    lstMemberType = MemberType.ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy thông tin loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> SelectToList");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách loại thành viên dạng List
        /// </summary>
        /// <param name="lstMemberType">Đối tượng loại thành viên</param>
        /// <param name="intPageSize">Số lượng Record một trang</param>
        /// <param name="intPageNumber">Lấy trang số mấy</param>
        /// <returns></returns>
        public ResultMessage SelectToList(ref List<SYS_MemberType> lstMemberType, int intPageSize, int intPageNumber)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var MemberType = from gu in db.SYS_MemberTypes
                               where gu.IsDeleted == false
                               orderby gu.OrderIndex
                               select gu;

                    lstMemberType = MemberType.Skip((intPageNumber - 1) * intPageSize).Take(intPageSize).ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy thông tin loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> SelectToList");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách loại thành viên để Cache
        /// </summary>
        /// <param name="lstMemberType"></param>
        /// <returns></returns>
        public ResultMessage SelectToCache(ref List<SYS_MemberType> lstMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {

                    IEnumerable<SYS_MemberType> MemberType = (from gu in db.SYS_MemberTypes
                                                  where gu.IsDeleted == false
                                                  orderby gu.OrderIndex
                                                  select new
                                                  {
                                                      IDSys = gu.IDSys,
                                                      MemberTypeName = gu.MemberTypeName,
                                                      Note = gu.Note,
                                                      OrderIndex = (Nullable<int>)gu.OrderIndex == null ? 0 : gu.OrderIndex
                                                  }).ToList().Select(c => new SYS_MemberType()
                                                  {
                                                      IDSys = c.IDSys,
                                                      MemberTypeName = c.MemberTypeName,
                                                      Note = c.Note,
                                                      OrderIndex = (Nullable<int>)c.OrderIndex == null ? 0 : 0
                                                  });

                    lstMemberType = MemberType.ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy Cache danh sách loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_MemberType --> SelectToListCache");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách loại thành viên thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách loại thành viên từ Cache
        /// </summary>
        /// <param name="lstMemberType"></param>
        /// <returns></returns>
        public ResultMessage SelectToListCache(ref List<SYS_MemberType> lstMemberType)
        {
            ResultMessage objResultMessage = new ResultMessage();
            objResultMessage = MPR.Poker.DALEntity.DataCache.GetDataCache.GetMemberType(ref lstMemberType);
            return objResultMessage;
        }

        #endregion
    }
}
